home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / mozilla-firefox / include / dom / nsIDOMSVGPathSeg.h < prev    next >
C/C++ Source or Header  |  2006-05-08  |  77KB  |  2,426 lines
  1. /*
  2.  * DO NOT EDIT.  THIS FILE IS GENERATED FROM nsIDOMSVGPathSeg.idl
  3.  */
  4.  
  5. #ifndef __gen_nsIDOMSVGPathSeg_h__
  6. #define __gen_nsIDOMSVGPathSeg_h__
  7.  
  8.  
  9. #ifndef __gen_domstubs_h__
  10. #include "domstubs.h"
  11. #endif
  12.  
  13. /* For IDL files that don't want to include root IDL files. */
  14. #ifndef NS_NO_VTABLE
  15. #define NS_NO_VTABLE
  16. #endif
  17.  
  18. /* starting interface:    nsIDOMSVGPathSeg */
  19. #define NS_IDOMSVGPATHSEG_IID_STR "b9022da7-e26d-4df3-8c94-b45c4aedda7c"
  20.  
  21. #define NS_IDOMSVGPATHSEG_IID \
  22.   {0xb9022da7, 0xe26d, 0x4df3, \
  23.     { 0x8c, 0x94, 0xb4, 0x5c, 0x4a, 0xed, 0xda, 0x7c }}
  24.  
  25. class NS_NO_VTABLE nsIDOMSVGPathSeg : public nsISupports {
  26.  public: 
  27.  
  28.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEG_IID)
  29.  
  30.   enum { PATHSEG_UNKNOWN = 0U };
  31.  
  32.   enum { PATHSEG_CLOSEPATH = 1U };
  33.  
  34.   enum { PATHSEG_MOVETO_ABS = 2U };
  35.  
  36.   enum { PATHSEG_MOVETO_REL = 3U };
  37.  
  38.   enum { PATHSEG_LINETO_ABS = 4U };
  39.  
  40.   enum { PATHSEG_LINETO_REL = 5U };
  41.  
  42.   enum { PATHSEG_CURVETO_CUBIC_ABS = 6U };
  43.  
  44.   enum { PATHSEG_CURVETO_CUBIC_REL = 7U };
  45.  
  46.   enum { PATHSEG_CURVETO_QUADRATIC_ABS = 8U };
  47.  
  48.   enum { PATHSEG_CURVETO_QUADRATIC_REL = 9U };
  49.  
  50.   enum { PATHSEG_ARC_ABS = 10U };
  51.  
  52.   enum { PATHSEG_ARC_REL = 11U };
  53.  
  54.   enum { PATHSEG_LINETO_HORIZONTAL_ABS = 12U };
  55.  
  56.   enum { PATHSEG_LINETO_HORIZONTAL_REL = 13U };
  57.  
  58.   enum { PATHSEG_LINETO_VERTICAL_ABS = 14U };
  59.  
  60.   enum { PATHSEG_LINETO_VERTICAL_REL = 15U };
  61.  
  62.   enum { PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16U };
  63.  
  64.   enum { PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17U };
  65.  
  66.   enum { PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18U };
  67.  
  68.   enum { PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19U };
  69.  
  70.   /* readonly attribute unsigned short pathSegType; */
  71.   NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType) = 0;
  72.  
  73.   /* readonly attribute DOMString pathSegTypeAsLetter; */
  74.   NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter) = 0;
  75.  
  76. };
  77.  
  78. /* Use this macro when declaring classes that implement this interface. */
  79. #define NS_DECL_NSIDOMSVGPATHSEG \
  80.   NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType); \
  81.   NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter); 
  82.  
  83. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  84. #define NS_FORWARD_NSIDOMSVGPATHSEG(_to) \
  85.   NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType) { return _to GetPathSegType(aPathSegType); } \
  86.   NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter) { return _to GetPathSegTypeAsLetter(aPathSegTypeAsLetter); } 
  87.  
  88. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  89. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEG(_to) \
  90.   NS_IMETHOD GetPathSegType(PRUint16 *aPathSegType) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPathSegType(aPathSegType); } \
  91.   NS_IMETHOD GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetPathSegTypeAsLetter(aPathSegTypeAsLetter); } 
  92.  
  93. #if 0
  94. /* Use the code below as a template for the implementation class for this interface. */
  95.  
  96. /* Header file */
  97. class nsDOMSVGPathSeg : public nsIDOMSVGPathSeg
  98. {
  99. public:
  100.   NS_DECL_ISUPPORTS
  101.   NS_DECL_NSIDOMSVGPATHSEG
  102.  
  103.   nsDOMSVGPathSeg();
  104.  
  105. private:
  106.   ~nsDOMSVGPathSeg();
  107.  
  108. protected:
  109.   /* additional members */
  110. };
  111.  
  112. /* Implementation file */
  113. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSeg, nsIDOMSVGPathSeg)
  114.  
  115. nsDOMSVGPathSeg::nsDOMSVGPathSeg()
  116. {
  117.   /* member initializers and constructor code */
  118. }
  119.  
  120. nsDOMSVGPathSeg::~nsDOMSVGPathSeg()
  121. {
  122.   /* destructor code */
  123. }
  124.  
  125. /* readonly attribute unsigned short pathSegType; */
  126. NS_IMETHODIMP nsDOMSVGPathSeg::GetPathSegType(PRUint16 *aPathSegType)
  127. {
  128.     return NS_ERROR_NOT_IMPLEMENTED;
  129. }
  130.  
  131. /* readonly attribute DOMString pathSegTypeAsLetter; */
  132. NS_IMETHODIMP nsDOMSVGPathSeg::GetPathSegTypeAsLetter(nsAString & aPathSegTypeAsLetter)
  133. {
  134.     return NS_ERROR_NOT_IMPLEMENTED;
  135. }
  136.  
  137. /* End of implementation class template. */
  138. #endif
  139.  
  140.  
  141. /* starting interface:    nsIDOMSVGPathSegClosePath */
  142. #define NS_IDOMSVGPATHSEGCLOSEPATH_IID_STR "2b72d033-f115-45aa-9748-8c11ea07b845"
  143.  
  144. #define NS_IDOMSVGPATHSEGCLOSEPATH_IID \
  145.   {0x2b72d033, 0xf115, 0x45aa, \
  146.     { 0x97, 0x48, 0x8c, 0x11, 0xea, 0x07, 0xb8, 0x45 }}
  147.  
  148. class NS_NO_VTABLE nsIDOMSVGPathSegClosePath : public nsIDOMSVGPathSeg {
  149.  public: 
  150.  
  151.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCLOSEPATH_IID)
  152.  
  153. };
  154.  
  155. /* Use this macro when declaring classes that implement this interface. */
  156. #define NS_DECL_NSIDOMSVGPATHSEGCLOSEPATH \
  157.   /* no methods! */
  158.  
  159. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  160. #define NS_FORWARD_NSIDOMSVGPATHSEGCLOSEPATH(_to) \
  161.   /* no methods! */
  162.  
  163. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  164. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCLOSEPATH(_to) \
  165.   /* no methods! */
  166.  
  167. #if 0
  168. /* Use the code below as a template for the implementation class for this interface. */
  169.  
  170. /* Header file */
  171. class nsDOMSVGPathSegClosePath : public nsIDOMSVGPathSegClosePath
  172. {
  173. public:
  174.   NS_DECL_ISUPPORTS
  175.   NS_DECL_NSIDOMSVGPATHSEGCLOSEPATH
  176.  
  177.   nsDOMSVGPathSegClosePath();
  178.  
  179. private:
  180.   ~nsDOMSVGPathSegClosePath();
  181.  
  182. protected:
  183.   /* additional members */
  184. };
  185.  
  186. /* Implementation file */
  187. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegClosePath, nsIDOMSVGPathSegClosePath)
  188.  
  189. nsDOMSVGPathSegClosePath::nsDOMSVGPathSegClosePath()
  190. {
  191.   /* member initializers and constructor code */
  192. }
  193.  
  194. nsDOMSVGPathSegClosePath::~nsDOMSVGPathSegClosePath()
  195. {
  196.   /* destructor code */
  197. }
  198.  
  199. /* End of implementation class template. */
  200. #endif
  201.  
  202.  
  203. /* starting interface:    nsIDOMSVGPathSegMovetoAbs */
  204. #define NS_IDOMSVGPATHSEGMOVETOABS_IID_STR "b0106d01-9746-440b-b067-68ee043dabc3"
  205.  
  206. #define NS_IDOMSVGPATHSEGMOVETOABS_IID \
  207.   {0xb0106d01, 0x9746, 0x440b, \
  208.     { 0xb0, 0x67, 0x68, 0xee, 0x04, 0x3d, 0xab, 0xc3 }}
  209.  
  210. class NS_NO_VTABLE nsIDOMSVGPathSegMovetoAbs : public nsIDOMSVGPathSeg {
  211.  public: 
  212.  
  213.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGMOVETOABS_IID)
  214.  
  215.   /* attribute float x; */
  216.   NS_IMETHOD GetX(float *aX) = 0;
  217.   NS_IMETHOD SetX(float aX) = 0;
  218.  
  219.   /* attribute float y; */
  220.   NS_IMETHOD GetY(float *aY) = 0;
  221.   NS_IMETHOD SetY(float aY) = 0;
  222.  
  223. };
  224.  
  225. /* Use this macro when declaring classes that implement this interface. */
  226. #define NS_DECL_NSIDOMSVGPATHSEGMOVETOABS \
  227.   NS_IMETHOD GetX(float *aX); \
  228.   NS_IMETHOD SetX(float aX); \
  229.   NS_IMETHOD GetY(float *aY); \
  230.   NS_IMETHOD SetY(float aY); 
  231.  
  232. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  233. #define NS_FORWARD_NSIDOMSVGPATHSEGMOVETOABS(_to) \
  234.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  235.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  236.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  237.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  238.  
  239. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  240. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGMOVETOABS(_to) \
  241.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  242.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  243.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  244.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  245.  
  246. #if 0
  247. /* Use the code below as a template for the implementation class for this interface. */
  248.  
  249. /* Header file */
  250. class nsDOMSVGPathSegMovetoAbs : public nsIDOMSVGPathSegMovetoAbs
  251. {
  252. public:
  253.   NS_DECL_ISUPPORTS
  254.   NS_DECL_NSIDOMSVGPATHSEGMOVETOABS
  255.  
  256.   nsDOMSVGPathSegMovetoAbs();
  257.  
  258. private:
  259.   ~nsDOMSVGPathSegMovetoAbs();
  260.  
  261. protected:
  262.   /* additional members */
  263. };
  264.  
  265. /* Implementation file */
  266. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegMovetoAbs, nsIDOMSVGPathSegMovetoAbs)
  267.  
  268. nsDOMSVGPathSegMovetoAbs::nsDOMSVGPathSegMovetoAbs()
  269. {
  270.   /* member initializers and constructor code */
  271. }
  272.  
  273. nsDOMSVGPathSegMovetoAbs::~nsDOMSVGPathSegMovetoAbs()
  274. {
  275.   /* destructor code */
  276. }
  277.  
  278. /* attribute float x; */
  279. NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::GetX(float *aX)
  280. {
  281.     return NS_ERROR_NOT_IMPLEMENTED;
  282. }
  283. NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::SetX(float aX)
  284. {
  285.     return NS_ERROR_NOT_IMPLEMENTED;
  286. }
  287.  
  288. /* attribute float y; */
  289. NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::GetY(float *aY)
  290. {
  291.     return NS_ERROR_NOT_IMPLEMENTED;
  292. }
  293. NS_IMETHODIMP nsDOMSVGPathSegMovetoAbs::SetY(float aY)
  294. {
  295.     return NS_ERROR_NOT_IMPLEMENTED;
  296. }
  297.  
  298. /* End of implementation class template. */
  299. #endif
  300.  
  301.  
  302. /* starting interface:    nsIDOMSVGPathSegMovetoRel */
  303. #define NS_IDOMSVGPATHSEGMOVETOREL_IID_STR "c6ee1ddd-8b35-4e1b-b381-c063a28012d9"
  304.  
  305. #define NS_IDOMSVGPATHSEGMOVETOREL_IID \
  306.   {0xc6ee1ddd, 0x8b35, 0x4e1b, \
  307.     { 0xb3, 0x81, 0xc0, 0x63, 0xa2, 0x80, 0x12, 0xd9 }}
  308.  
  309. class NS_NO_VTABLE nsIDOMSVGPathSegMovetoRel : public nsIDOMSVGPathSeg {
  310.  public: 
  311.  
  312.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGMOVETOREL_IID)
  313.  
  314.   /* attribute float x; */
  315.   NS_IMETHOD GetX(float *aX) = 0;
  316.   NS_IMETHOD SetX(float aX) = 0;
  317.  
  318.   /* attribute float y; */
  319.   NS_IMETHOD GetY(float *aY) = 0;
  320.   NS_IMETHOD SetY(float aY) = 0;
  321.  
  322. };
  323.  
  324. /* Use this macro when declaring classes that implement this interface. */
  325. #define NS_DECL_NSIDOMSVGPATHSEGMOVETOREL \
  326.   NS_IMETHOD GetX(float *aX); \
  327.   NS_IMETHOD SetX(float aX); \
  328.   NS_IMETHOD GetY(float *aY); \
  329.   NS_IMETHOD SetY(float aY); 
  330.  
  331. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  332. #define NS_FORWARD_NSIDOMSVGPATHSEGMOVETOREL(_to) \
  333.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  334.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  335.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  336.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  337.  
  338. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  339. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGMOVETOREL(_to) \
  340.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  341.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  342.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  343.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  344.  
  345. #if 0
  346. /* Use the code below as a template for the implementation class for this interface. */
  347.  
  348. /* Header file */
  349. class nsDOMSVGPathSegMovetoRel : public nsIDOMSVGPathSegMovetoRel
  350. {
  351. public:
  352.   NS_DECL_ISUPPORTS
  353.   NS_DECL_NSIDOMSVGPATHSEGMOVETOREL
  354.  
  355.   nsDOMSVGPathSegMovetoRel();
  356.  
  357. private:
  358.   ~nsDOMSVGPathSegMovetoRel();
  359.  
  360. protected:
  361.   /* additional members */
  362. };
  363.  
  364. /* Implementation file */
  365. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegMovetoRel, nsIDOMSVGPathSegMovetoRel)
  366.  
  367. nsDOMSVGPathSegMovetoRel::nsDOMSVGPathSegMovetoRel()
  368. {
  369.   /* member initializers and constructor code */
  370. }
  371.  
  372. nsDOMSVGPathSegMovetoRel::~nsDOMSVGPathSegMovetoRel()
  373. {
  374.   /* destructor code */
  375. }
  376.  
  377. /* attribute float x; */
  378. NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::GetX(float *aX)
  379. {
  380.     return NS_ERROR_NOT_IMPLEMENTED;
  381. }
  382. NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::SetX(float aX)
  383. {
  384.     return NS_ERROR_NOT_IMPLEMENTED;
  385. }
  386.  
  387. /* attribute float y; */
  388. NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::GetY(float *aY)
  389. {
  390.     return NS_ERROR_NOT_IMPLEMENTED;
  391. }
  392. NS_IMETHODIMP nsDOMSVGPathSegMovetoRel::SetY(float aY)
  393. {
  394.     return NS_ERROR_NOT_IMPLEMENTED;
  395. }
  396.  
  397. /* End of implementation class template. */
  398. #endif
  399.  
  400.  
  401. /* starting interface:    nsIDOMSVGPathSegLinetoAbs */
  402. #define NS_IDOMSVGPATHSEGLINETOABS_IID_STR "bac3648d-55a3-491b-9863-a18fd7506689"
  403.  
  404. #define NS_IDOMSVGPATHSEGLINETOABS_IID \
  405.   {0xbac3648d, 0x55a3, 0x491b, \
  406.     { 0x98, 0x63, 0xa1, 0x8f, 0xd7, 0x50, 0x66, 0x89 }}
  407.  
  408. class NS_NO_VTABLE nsIDOMSVGPathSegLinetoAbs : public nsIDOMSVGPathSeg {
  409.  public: 
  410.  
  411.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOABS_IID)
  412.  
  413.   /* attribute float x; */
  414.   NS_IMETHOD GetX(float *aX) = 0;
  415.   NS_IMETHOD SetX(float aX) = 0;
  416.  
  417.   /* attribute float y; */
  418.   NS_IMETHOD GetY(float *aY) = 0;
  419.   NS_IMETHOD SetY(float aY) = 0;
  420.  
  421. };
  422.  
  423. /* Use this macro when declaring classes that implement this interface. */
  424. #define NS_DECL_NSIDOMSVGPATHSEGLINETOABS \
  425.   NS_IMETHOD GetX(float *aX); \
  426.   NS_IMETHOD SetX(float aX); \
  427.   NS_IMETHOD GetY(float *aY); \
  428.   NS_IMETHOD SetY(float aY); 
  429.  
  430. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  431. #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOABS(_to) \
  432.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  433.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  434.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  435.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  436.  
  437. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  438. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOABS(_to) \
  439.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  440.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  441.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  442.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  443.  
  444. #if 0
  445. /* Use the code below as a template for the implementation class for this interface. */
  446.  
  447. /* Header file */
  448. class nsDOMSVGPathSegLinetoAbs : public nsIDOMSVGPathSegLinetoAbs
  449. {
  450. public:
  451.   NS_DECL_ISUPPORTS
  452.   NS_DECL_NSIDOMSVGPATHSEGLINETOABS
  453.  
  454.   nsDOMSVGPathSegLinetoAbs();
  455.  
  456. private:
  457.   ~nsDOMSVGPathSegLinetoAbs();
  458.  
  459. protected:
  460.   /* additional members */
  461. };
  462.  
  463. /* Implementation file */
  464. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoAbs, nsIDOMSVGPathSegLinetoAbs)
  465.  
  466. nsDOMSVGPathSegLinetoAbs::nsDOMSVGPathSegLinetoAbs()
  467. {
  468.   /* member initializers and constructor code */
  469. }
  470.  
  471. nsDOMSVGPathSegLinetoAbs::~nsDOMSVGPathSegLinetoAbs()
  472. {
  473.   /* destructor code */
  474. }
  475.  
  476. /* attribute float x; */
  477. NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::GetX(float *aX)
  478. {
  479.     return NS_ERROR_NOT_IMPLEMENTED;
  480. }
  481. NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::SetX(float aX)
  482. {
  483.     return NS_ERROR_NOT_IMPLEMENTED;
  484. }
  485.  
  486. /* attribute float y; */
  487. NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::GetY(float *aY)
  488. {
  489.     return NS_ERROR_NOT_IMPLEMENTED;
  490. }
  491. NS_IMETHODIMP nsDOMSVGPathSegLinetoAbs::SetY(float aY)
  492. {
  493.     return NS_ERROR_NOT_IMPLEMENTED;
  494. }
  495.  
  496. /* End of implementation class template. */
  497. #endif
  498.  
  499.  
  500. /* starting interface:    nsIDOMSVGPathSegLinetoRel */
  501. #define NS_IDOMSVGPATHSEGLINETOREL_IID_STR "3294d20e-c707-4e59-a625-bde93fc0b25f"
  502.  
  503. #define NS_IDOMSVGPATHSEGLINETOREL_IID \
  504.   {0x3294d20e, 0xc707, 0x4e59, \
  505.     { 0xa6, 0x25, 0xbd, 0xe9, 0x3f, 0xc0, 0xb2, 0x5f }}
  506.  
  507. class NS_NO_VTABLE nsIDOMSVGPathSegLinetoRel : public nsIDOMSVGPathSeg {
  508.  public: 
  509.  
  510.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOREL_IID)
  511.  
  512.   /* attribute float x; */
  513.   NS_IMETHOD GetX(float *aX) = 0;
  514.   NS_IMETHOD SetX(float aX) = 0;
  515.  
  516.   /* attribute float y; */
  517.   NS_IMETHOD GetY(float *aY) = 0;
  518.   NS_IMETHOD SetY(float aY) = 0;
  519.  
  520. };
  521.  
  522. /* Use this macro when declaring classes that implement this interface. */
  523. #define NS_DECL_NSIDOMSVGPATHSEGLINETOREL \
  524.   NS_IMETHOD GetX(float *aX); \
  525.   NS_IMETHOD SetX(float aX); \
  526.   NS_IMETHOD GetY(float *aY); \
  527.   NS_IMETHOD SetY(float aY); 
  528.  
  529. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  530. #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOREL(_to) \
  531.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  532.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  533.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  534.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  535.  
  536. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  537. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOREL(_to) \
  538.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  539.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  540.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  541.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  542.  
  543. #if 0
  544. /* Use the code below as a template for the implementation class for this interface. */
  545.  
  546. /* Header file */
  547. class nsDOMSVGPathSegLinetoRel : public nsIDOMSVGPathSegLinetoRel
  548. {
  549. public:
  550.   NS_DECL_ISUPPORTS
  551.   NS_DECL_NSIDOMSVGPATHSEGLINETOREL
  552.  
  553.   nsDOMSVGPathSegLinetoRel();
  554.  
  555. private:
  556.   ~nsDOMSVGPathSegLinetoRel();
  557.  
  558. protected:
  559.   /* additional members */
  560. };
  561.  
  562. /* Implementation file */
  563. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoRel, nsIDOMSVGPathSegLinetoRel)
  564.  
  565. nsDOMSVGPathSegLinetoRel::nsDOMSVGPathSegLinetoRel()
  566. {
  567.   /* member initializers and constructor code */
  568. }
  569.  
  570. nsDOMSVGPathSegLinetoRel::~nsDOMSVGPathSegLinetoRel()
  571. {
  572.   /* destructor code */
  573. }
  574.  
  575. /* attribute float x; */
  576. NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::GetX(float *aX)
  577. {
  578.     return NS_ERROR_NOT_IMPLEMENTED;
  579. }
  580. NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::SetX(float aX)
  581. {
  582.     return NS_ERROR_NOT_IMPLEMENTED;
  583. }
  584.  
  585. /* attribute float y; */
  586. NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::GetY(float *aY)
  587. {
  588.     return NS_ERROR_NOT_IMPLEMENTED;
  589. }
  590. NS_IMETHODIMP nsDOMSVGPathSegLinetoRel::SetY(float aY)
  591. {
  592.     return NS_ERROR_NOT_IMPLEMENTED;
  593. }
  594.  
  595. /* End of implementation class template. */
  596. #endif
  597.  
  598.  
  599. /* starting interface:    nsIDOMSVGPathSegCurvetoCubicAbs */
  600. #define NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID_STR "ad929b96-ef81-4002-b596-c6a8b3a878e9"
  601.  
  602. #define NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID \
  603.   {0xad929b96, 0xef81, 0x4002, \
  604.     { 0xb5, 0x96, 0xc6, 0xa8, 0xb3, 0xa8, 0x78, 0xe9 }}
  605.  
  606. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoCubicAbs : public nsIDOMSVGPathSeg {
  607.  public: 
  608.  
  609.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICABS_IID)
  610.  
  611.   /* attribute float x; */
  612.   NS_IMETHOD GetX(float *aX) = 0;
  613.   NS_IMETHOD SetX(float aX) = 0;
  614.  
  615.   /* attribute float y; */
  616.   NS_IMETHOD GetY(float *aY) = 0;
  617.   NS_IMETHOD SetY(float aY) = 0;
  618.  
  619.   /* attribute float x1; */
  620.   NS_IMETHOD GetX1(float *aX1) = 0;
  621.   NS_IMETHOD SetX1(float aX1) = 0;
  622.  
  623.   /* attribute float y1; */
  624.   NS_IMETHOD GetY1(float *aY1) = 0;
  625.   NS_IMETHOD SetY1(float aY1) = 0;
  626.  
  627.   /* attribute float x2; */
  628.   NS_IMETHOD GetX2(float *aX2) = 0;
  629.   NS_IMETHOD SetX2(float aX2) = 0;
  630.  
  631.   /* attribute float y2; */
  632.   NS_IMETHOD GetY2(float *aY2) = 0;
  633.   NS_IMETHOD SetY2(float aY2) = 0;
  634.  
  635. };
  636.  
  637. /* Use this macro when declaring classes that implement this interface. */
  638. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICABS \
  639.   NS_IMETHOD GetX(float *aX); \
  640.   NS_IMETHOD SetX(float aX); \
  641.   NS_IMETHOD GetY(float *aY); \
  642.   NS_IMETHOD SetY(float aY); \
  643.   NS_IMETHOD GetX1(float *aX1); \
  644.   NS_IMETHOD SetX1(float aX1); \
  645.   NS_IMETHOD GetY1(float *aY1); \
  646.   NS_IMETHOD SetY1(float aY1); \
  647.   NS_IMETHOD GetX2(float *aX2); \
  648.   NS_IMETHOD SetX2(float aX2); \
  649.   NS_IMETHOD GetY2(float *aY2); \
  650.   NS_IMETHOD SetY2(float aY2); 
  651.  
  652. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  653. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICABS(_to) \
  654.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  655.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  656.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  657.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  658.   NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
  659.   NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
  660.   NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
  661.   NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); } \
  662.   NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
  663.   NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
  664.   NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
  665.   NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); } 
  666.  
  667. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  668. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICABS(_to) \
  669.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  670.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  671.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  672.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  673.   NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
  674.   NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
  675.   NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
  676.   NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); } \
  677.   NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
  678.   NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
  679.   NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
  680.   NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); } 
  681.  
  682. #if 0
  683. /* Use the code below as a template for the implementation class for this interface. */
  684.  
  685. /* Header file */
  686. class nsDOMSVGPathSegCurvetoCubicAbs : public nsIDOMSVGPathSegCurvetoCubicAbs
  687. {
  688. public:
  689.   NS_DECL_ISUPPORTS
  690.   NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICABS
  691.  
  692.   nsDOMSVGPathSegCurvetoCubicAbs();
  693.  
  694. private:
  695.   ~nsDOMSVGPathSegCurvetoCubicAbs();
  696.  
  697. protected:
  698.   /* additional members */
  699. };
  700.  
  701. /* Implementation file */
  702. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicAbs, nsIDOMSVGPathSegCurvetoCubicAbs)
  703.  
  704. nsDOMSVGPathSegCurvetoCubicAbs::nsDOMSVGPathSegCurvetoCubicAbs()
  705. {
  706.   /* member initializers and constructor code */
  707. }
  708.  
  709. nsDOMSVGPathSegCurvetoCubicAbs::~nsDOMSVGPathSegCurvetoCubicAbs()
  710. {
  711.   /* destructor code */
  712. }
  713.  
  714. /* attribute float x; */
  715. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetX(float *aX)
  716. {
  717.     return NS_ERROR_NOT_IMPLEMENTED;
  718. }
  719. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetX(float aX)
  720. {
  721.     return NS_ERROR_NOT_IMPLEMENTED;
  722. }
  723.  
  724. /* attribute float y; */
  725. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetY(float *aY)
  726. {
  727.     return NS_ERROR_NOT_IMPLEMENTED;
  728. }
  729. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetY(float aY)
  730. {
  731.     return NS_ERROR_NOT_IMPLEMENTED;
  732. }
  733.  
  734. /* attribute float x1; */
  735. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetX1(float *aX1)
  736. {
  737.     return NS_ERROR_NOT_IMPLEMENTED;
  738. }
  739. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetX1(float aX1)
  740. {
  741.     return NS_ERROR_NOT_IMPLEMENTED;
  742. }
  743.  
  744. /* attribute float y1; */
  745. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetY1(float *aY1)
  746. {
  747.     return NS_ERROR_NOT_IMPLEMENTED;
  748. }
  749. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetY1(float aY1)
  750. {
  751.     return NS_ERROR_NOT_IMPLEMENTED;
  752. }
  753.  
  754. /* attribute float x2; */
  755. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetX2(float *aX2)
  756. {
  757.     return NS_ERROR_NOT_IMPLEMENTED;
  758. }
  759. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetX2(float aX2)
  760. {
  761.     return NS_ERROR_NOT_IMPLEMENTED;
  762. }
  763.  
  764. /* attribute float y2; */
  765. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::GetY2(float *aY2)
  766. {
  767.     return NS_ERROR_NOT_IMPLEMENTED;
  768. }
  769. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicAbs::SetY2(float aY2)
  770. {
  771.     return NS_ERROR_NOT_IMPLEMENTED;
  772. }
  773.  
  774. /* End of implementation class template. */
  775. #endif
  776.  
  777.  
  778. /* starting interface:    nsIDOMSVGPathSegCurvetoCubicRel */
  779. #define NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID_STR "dc7ba13f-8cb6-48d2-9e22-a4a6817abbb9"
  780.  
  781. #define NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID \
  782.   {0xdc7ba13f, 0x8cb6, 0x48d2, \
  783.     { 0x9e, 0x22, 0xa4, 0xa6, 0x81, 0x7a, 0xbb, 0xb9 }}
  784.  
  785. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoCubicRel : public nsIDOMSVGPathSeg {
  786.  public: 
  787.  
  788.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICREL_IID)
  789.  
  790.   /* attribute float x; */
  791.   NS_IMETHOD GetX(float *aX) = 0;
  792.   NS_IMETHOD SetX(float aX) = 0;
  793.  
  794.   /* attribute float y; */
  795.   NS_IMETHOD GetY(float *aY) = 0;
  796.   NS_IMETHOD SetY(float aY) = 0;
  797.  
  798.   /* attribute float x1; */
  799.   NS_IMETHOD GetX1(float *aX1) = 0;
  800.   NS_IMETHOD SetX1(float aX1) = 0;
  801.  
  802.   /* attribute float y1; */
  803.   NS_IMETHOD GetY1(float *aY1) = 0;
  804.   NS_IMETHOD SetY1(float aY1) = 0;
  805.  
  806.   /* attribute float x2; */
  807.   NS_IMETHOD GetX2(float *aX2) = 0;
  808.   NS_IMETHOD SetX2(float aX2) = 0;
  809.  
  810.   /* attribute float y2; */
  811.   NS_IMETHOD GetY2(float *aY2) = 0;
  812.   NS_IMETHOD SetY2(float aY2) = 0;
  813.  
  814. };
  815.  
  816. /* Use this macro when declaring classes that implement this interface. */
  817. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICREL \
  818.   NS_IMETHOD GetX(float *aX); \
  819.   NS_IMETHOD SetX(float aX); \
  820.   NS_IMETHOD GetY(float *aY); \
  821.   NS_IMETHOD SetY(float aY); \
  822.   NS_IMETHOD GetX1(float *aX1); \
  823.   NS_IMETHOD SetX1(float aX1); \
  824.   NS_IMETHOD GetY1(float *aY1); \
  825.   NS_IMETHOD SetY1(float aY1); \
  826.   NS_IMETHOD GetX2(float *aX2); \
  827.   NS_IMETHOD SetX2(float aX2); \
  828.   NS_IMETHOD GetY2(float *aY2); \
  829.   NS_IMETHOD SetY2(float aY2); 
  830.  
  831. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  832. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICREL(_to) \
  833.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  834.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  835.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  836.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  837.   NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
  838.   NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
  839.   NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
  840.   NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); } \
  841.   NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
  842.   NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
  843.   NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
  844.   NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); } 
  845.  
  846. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  847. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICREL(_to) \
  848.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  849.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  850.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  851.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  852.   NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
  853.   NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
  854.   NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
  855.   NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); } \
  856.   NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
  857.   NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
  858.   NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
  859.   NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); } 
  860.  
  861. #if 0
  862. /* Use the code below as a template for the implementation class for this interface. */
  863.  
  864. /* Header file */
  865. class nsDOMSVGPathSegCurvetoCubicRel : public nsIDOMSVGPathSegCurvetoCubicRel
  866. {
  867. public:
  868.   NS_DECL_ISUPPORTS
  869.   NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICREL
  870.  
  871.   nsDOMSVGPathSegCurvetoCubicRel();
  872.  
  873. private:
  874.   ~nsDOMSVGPathSegCurvetoCubicRel();
  875.  
  876. protected:
  877.   /* additional members */
  878. };
  879.  
  880. /* Implementation file */
  881. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicRel, nsIDOMSVGPathSegCurvetoCubicRel)
  882.  
  883. nsDOMSVGPathSegCurvetoCubicRel::nsDOMSVGPathSegCurvetoCubicRel()
  884. {
  885.   /* member initializers and constructor code */
  886. }
  887.  
  888. nsDOMSVGPathSegCurvetoCubicRel::~nsDOMSVGPathSegCurvetoCubicRel()
  889. {
  890.   /* destructor code */
  891. }
  892.  
  893. /* attribute float x; */
  894. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetX(float *aX)
  895. {
  896.     return NS_ERROR_NOT_IMPLEMENTED;
  897. }
  898. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetX(float aX)
  899. {
  900.     return NS_ERROR_NOT_IMPLEMENTED;
  901. }
  902.  
  903. /* attribute float y; */
  904. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetY(float *aY)
  905. {
  906.     return NS_ERROR_NOT_IMPLEMENTED;
  907. }
  908. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetY(float aY)
  909. {
  910.     return NS_ERROR_NOT_IMPLEMENTED;
  911. }
  912.  
  913. /* attribute float x1; */
  914. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetX1(float *aX1)
  915. {
  916.     return NS_ERROR_NOT_IMPLEMENTED;
  917. }
  918. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetX1(float aX1)
  919. {
  920.     return NS_ERROR_NOT_IMPLEMENTED;
  921. }
  922.  
  923. /* attribute float y1; */
  924. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetY1(float *aY1)
  925. {
  926.     return NS_ERROR_NOT_IMPLEMENTED;
  927. }
  928. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetY1(float aY1)
  929. {
  930.     return NS_ERROR_NOT_IMPLEMENTED;
  931. }
  932.  
  933. /* attribute float x2; */
  934. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetX2(float *aX2)
  935. {
  936.     return NS_ERROR_NOT_IMPLEMENTED;
  937. }
  938. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetX2(float aX2)
  939. {
  940.     return NS_ERROR_NOT_IMPLEMENTED;
  941. }
  942.  
  943. /* attribute float y2; */
  944. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::GetY2(float *aY2)
  945. {
  946.     return NS_ERROR_NOT_IMPLEMENTED;
  947. }
  948. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicRel::SetY2(float aY2)
  949. {
  950.     return NS_ERROR_NOT_IMPLEMENTED;
  951. }
  952.  
  953. /* End of implementation class template. */
  954. #endif
  955.  
  956.  
  957. /* starting interface:    nsIDOMSVGPathSegCurvetoQuadraticAbs */
  958. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID_STR "ec4e8f65-5f4a-495e-a5f2-00e18d5e5f96"
  959.  
  960. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID \
  961.   {0xec4e8f65, 0x5f4a, 0x495e, \
  962.     { 0xa5, 0xf2, 0x00, 0xe1, 0x8d, 0x5e, 0x5f, 0x96 }}
  963.  
  964. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoQuadraticAbs : public nsIDOMSVGPathSeg {
  965.  public: 
  966.  
  967.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICABS_IID)
  968.  
  969.   /* attribute float x; */
  970.   NS_IMETHOD GetX(float *aX) = 0;
  971.   NS_IMETHOD SetX(float aX) = 0;
  972.  
  973.   /* attribute float y; */
  974.   NS_IMETHOD GetY(float *aY) = 0;
  975.   NS_IMETHOD SetY(float aY) = 0;
  976.  
  977.   /* attribute float x1; */
  978.   NS_IMETHOD GetX1(float *aX1) = 0;
  979.   NS_IMETHOD SetX1(float aX1) = 0;
  980.  
  981.   /* attribute float y1; */
  982.   NS_IMETHOD GetY1(float *aY1) = 0;
  983.   NS_IMETHOD SetY1(float aY1) = 0;
  984.  
  985. };
  986.  
  987. /* Use this macro when declaring classes that implement this interface. */
  988. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICABS \
  989.   NS_IMETHOD GetX(float *aX); \
  990.   NS_IMETHOD SetX(float aX); \
  991.   NS_IMETHOD GetY(float *aY); \
  992.   NS_IMETHOD SetY(float aY); \
  993.   NS_IMETHOD GetX1(float *aX1); \
  994.   NS_IMETHOD SetX1(float aX1); \
  995.   NS_IMETHOD GetY1(float *aY1); \
  996.   NS_IMETHOD SetY1(float aY1); 
  997.  
  998. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  999. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICABS(_to) \
  1000.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1001.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  1002.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1003.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  1004.   NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
  1005.   NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
  1006.   NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
  1007.   NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); } 
  1008.  
  1009. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1010. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICABS(_to) \
  1011.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  1012.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  1013.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  1014.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  1015.   NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
  1016.   NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
  1017.   NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
  1018.   NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); } 
  1019.  
  1020. #if 0
  1021. /* Use the code below as a template for the implementation class for this interface. */
  1022.  
  1023. /* Header file */
  1024. class nsDOMSVGPathSegCurvetoQuadraticAbs : public nsIDOMSVGPathSegCurvetoQuadraticAbs
  1025. {
  1026. public:
  1027.   NS_DECL_ISUPPORTS
  1028.   NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICABS
  1029.  
  1030.   nsDOMSVGPathSegCurvetoQuadraticAbs();
  1031.  
  1032. private:
  1033.   ~nsDOMSVGPathSegCurvetoQuadraticAbs();
  1034.  
  1035. protected:
  1036.   /* additional members */
  1037. };
  1038.  
  1039. /* Implementation file */
  1040. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticAbs, nsIDOMSVGPathSegCurvetoQuadraticAbs)
  1041.  
  1042. nsDOMSVGPathSegCurvetoQuadraticAbs::nsDOMSVGPathSegCurvetoQuadraticAbs()
  1043. {
  1044.   /* member initializers and constructor code */
  1045. }
  1046.  
  1047. nsDOMSVGPathSegCurvetoQuadraticAbs::~nsDOMSVGPathSegCurvetoQuadraticAbs()
  1048. {
  1049.   /* destructor code */
  1050. }
  1051.  
  1052. /* attribute float x; */
  1053. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetX(float *aX)
  1054. {
  1055.     return NS_ERROR_NOT_IMPLEMENTED;
  1056. }
  1057. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetX(float aX)
  1058. {
  1059.     return NS_ERROR_NOT_IMPLEMENTED;
  1060. }
  1061.  
  1062. /* attribute float y; */
  1063. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetY(float *aY)
  1064. {
  1065.     return NS_ERROR_NOT_IMPLEMENTED;
  1066. }
  1067. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetY(float aY)
  1068. {
  1069.     return NS_ERROR_NOT_IMPLEMENTED;
  1070. }
  1071.  
  1072. /* attribute float x1; */
  1073. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetX1(float *aX1)
  1074. {
  1075.     return NS_ERROR_NOT_IMPLEMENTED;
  1076. }
  1077. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetX1(float aX1)
  1078. {
  1079.     return NS_ERROR_NOT_IMPLEMENTED;
  1080. }
  1081.  
  1082. /* attribute float y1; */
  1083. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::GetY1(float *aY1)
  1084. {
  1085.     return NS_ERROR_NOT_IMPLEMENTED;
  1086. }
  1087. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticAbs::SetY1(float aY1)
  1088. {
  1089.     return NS_ERROR_NOT_IMPLEMENTED;
  1090. }
  1091.  
  1092. /* End of implementation class template. */
  1093. #endif
  1094.  
  1095.  
  1096. /* starting interface:    nsIDOMSVGPathSegCurvetoQuadraticRel */
  1097. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID_STR "7007113c-e06b-4256-8530-4884d5d769c6"
  1098.  
  1099. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID \
  1100.   {0x7007113c, 0xe06b, 0x4256, \
  1101.     { 0x85, 0x30, 0x48, 0x84, 0xd5, 0xd7, 0x69, 0xc6 }}
  1102.  
  1103. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoQuadraticRel : public nsIDOMSVGPathSeg {
  1104.  public: 
  1105.  
  1106.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICREL_IID)
  1107.  
  1108.   /* attribute float x; */
  1109.   NS_IMETHOD GetX(float *aX) = 0;
  1110.   NS_IMETHOD SetX(float aX) = 0;
  1111.  
  1112.   /* attribute float y; */
  1113.   NS_IMETHOD GetY(float *aY) = 0;
  1114.   NS_IMETHOD SetY(float aY) = 0;
  1115.  
  1116.   /* attribute float x1; */
  1117.   NS_IMETHOD GetX1(float *aX1) = 0;
  1118.   NS_IMETHOD SetX1(float aX1) = 0;
  1119.  
  1120.   /* attribute float y1; */
  1121.   NS_IMETHOD GetY1(float *aY1) = 0;
  1122.   NS_IMETHOD SetY1(float aY1) = 0;
  1123.  
  1124. };
  1125.  
  1126. /* Use this macro when declaring classes that implement this interface. */
  1127. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICREL \
  1128.   NS_IMETHOD GetX(float *aX); \
  1129.   NS_IMETHOD SetX(float aX); \
  1130.   NS_IMETHOD GetY(float *aY); \
  1131.   NS_IMETHOD SetY(float aY); \
  1132.   NS_IMETHOD GetX1(float *aX1); \
  1133.   NS_IMETHOD SetX1(float aX1); \
  1134.   NS_IMETHOD GetY1(float *aY1); \
  1135.   NS_IMETHOD SetY1(float aY1); 
  1136.  
  1137. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1138. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICREL(_to) \
  1139.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1140.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  1141.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1142.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  1143.   NS_IMETHOD GetX1(float *aX1) { return _to GetX1(aX1); } \
  1144.   NS_IMETHOD SetX1(float aX1) { return _to SetX1(aX1); } \
  1145.   NS_IMETHOD GetY1(float *aY1) { return _to GetY1(aY1); } \
  1146.   NS_IMETHOD SetY1(float aY1) { return _to SetY1(aY1); } 
  1147.  
  1148. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1149. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICREL(_to) \
  1150.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  1151.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  1152.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  1153.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  1154.   NS_IMETHOD GetX1(float *aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX1(aX1); } \
  1155.   NS_IMETHOD SetX1(float aX1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX1(aX1); } \
  1156.   NS_IMETHOD GetY1(float *aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY1(aY1); } \
  1157.   NS_IMETHOD SetY1(float aY1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY1(aY1); } 
  1158.  
  1159. #if 0
  1160. /* Use the code below as a template for the implementation class for this interface. */
  1161.  
  1162. /* Header file */
  1163. class nsDOMSVGPathSegCurvetoQuadraticRel : public nsIDOMSVGPathSegCurvetoQuadraticRel
  1164. {
  1165. public:
  1166.   NS_DECL_ISUPPORTS
  1167.   NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICREL
  1168.  
  1169.   nsDOMSVGPathSegCurvetoQuadraticRel();
  1170.  
  1171. private:
  1172.   ~nsDOMSVGPathSegCurvetoQuadraticRel();
  1173.  
  1174. protected:
  1175.   /* additional members */
  1176. };
  1177.  
  1178. /* Implementation file */
  1179. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticRel, nsIDOMSVGPathSegCurvetoQuadraticRel)
  1180.  
  1181. nsDOMSVGPathSegCurvetoQuadraticRel::nsDOMSVGPathSegCurvetoQuadraticRel()
  1182. {
  1183.   /* member initializers and constructor code */
  1184. }
  1185.  
  1186. nsDOMSVGPathSegCurvetoQuadraticRel::~nsDOMSVGPathSegCurvetoQuadraticRel()
  1187. {
  1188.   /* destructor code */
  1189. }
  1190.  
  1191. /* attribute float x; */
  1192. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetX(float *aX)
  1193. {
  1194.     return NS_ERROR_NOT_IMPLEMENTED;
  1195. }
  1196. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetX(float aX)
  1197. {
  1198.     return NS_ERROR_NOT_IMPLEMENTED;
  1199. }
  1200.  
  1201. /* attribute float y; */
  1202. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetY(float *aY)
  1203. {
  1204.     return NS_ERROR_NOT_IMPLEMENTED;
  1205. }
  1206. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetY(float aY)
  1207. {
  1208.     return NS_ERROR_NOT_IMPLEMENTED;
  1209. }
  1210.  
  1211. /* attribute float x1; */
  1212. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetX1(float *aX1)
  1213. {
  1214.     return NS_ERROR_NOT_IMPLEMENTED;
  1215. }
  1216. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetX1(float aX1)
  1217. {
  1218.     return NS_ERROR_NOT_IMPLEMENTED;
  1219. }
  1220.  
  1221. /* attribute float y1; */
  1222. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::GetY1(float *aY1)
  1223. {
  1224.     return NS_ERROR_NOT_IMPLEMENTED;
  1225. }
  1226. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticRel::SetY1(float aY1)
  1227. {
  1228.     return NS_ERROR_NOT_IMPLEMENTED;
  1229. }
  1230.  
  1231. /* End of implementation class template. */
  1232. #endif
  1233.  
  1234.  
  1235. /* starting interface:    nsIDOMSVGPathSegArcAbs */
  1236. #define NS_IDOMSVGPATHSEGARCABS_IID_STR "c26e1779-604b-4bad-8a29-02d2a2113769"
  1237.  
  1238. #define NS_IDOMSVGPATHSEGARCABS_IID \
  1239.   {0xc26e1779, 0x604b, 0x4bad, \
  1240.     { 0x8a, 0x29, 0x02, 0xd2, 0xa2, 0x11, 0x37, 0x69 }}
  1241.  
  1242. class NS_NO_VTABLE nsIDOMSVGPathSegArcAbs : public nsIDOMSVGPathSeg {
  1243.  public: 
  1244.  
  1245.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGARCABS_IID)
  1246.  
  1247.   /* attribute float x; */
  1248.   NS_IMETHOD GetX(float *aX) = 0;
  1249.   NS_IMETHOD SetX(float aX) = 0;
  1250.  
  1251.   /* attribute float y; */
  1252.   NS_IMETHOD GetY(float *aY) = 0;
  1253.   NS_IMETHOD SetY(float aY) = 0;
  1254.  
  1255.   /* attribute float r1; */
  1256.   NS_IMETHOD GetR1(float *aR1) = 0;
  1257.   NS_IMETHOD SetR1(float aR1) = 0;
  1258.  
  1259.   /* attribute float r2; */
  1260.   NS_IMETHOD GetR2(float *aR2) = 0;
  1261.   NS_IMETHOD SetR2(float aR2) = 0;
  1262.  
  1263.   /* attribute float angle; */
  1264.   NS_IMETHOD GetAngle(float *aAngle) = 0;
  1265.   NS_IMETHOD SetAngle(float aAngle) = 0;
  1266.  
  1267.   /* attribute boolean largeArcFlag; */
  1268.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag) = 0;
  1269.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag) = 0;
  1270.  
  1271.   /* attribute boolean sweepFlag; */
  1272.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag) = 0;
  1273.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag) = 0;
  1274.  
  1275. };
  1276.  
  1277. /* Use this macro when declaring classes that implement this interface. */
  1278. #define NS_DECL_NSIDOMSVGPATHSEGARCABS \
  1279.   NS_IMETHOD GetX(float *aX); \
  1280.   NS_IMETHOD SetX(float aX); \
  1281.   NS_IMETHOD GetY(float *aY); \
  1282.   NS_IMETHOD SetY(float aY); \
  1283.   NS_IMETHOD GetR1(float *aR1); \
  1284.   NS_IMETHOD SetR1(float aR1); \
  1285.   NS_IMETHOD GetR2(float *aR2); \
  1286.   NS_IMETHOD SetR2(float aR2); \
  1287.   NS_IMETHOD GetAngle(float *aAngle); \
  1288.   NS_IMETHOD SetAngle(float aAngle); \
  1289.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag); \
  1290.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag); \
  1291.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag); \
  1292.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag); 
  1293.  
  1294. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1295. #define NS_FORWARD_NSIDOMSVGPATHSEGARCABS(_to) \
  1296.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1297.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  1298.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1299.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  1300.   NS_IMETHOD GetR1(float *aR1) { return _to GetR1(aR1); } \
  1301.   NS_IMETHOD SetR1(float aR1) { return _to SetR1(aR1); } \
  1302.   NS_IMETHOD GetR2(float *aR2) { return _to GetR2(aR2); } \
  1303.   NS_IMETHOD SetR2(float aR2) { return _to SetR2(aR2); } \
  1304.   NS_IMETHOD GetAngle(float *aAngle) { return _to GetAngle(aAngle); } \
  1305.   NS_IMETHOD SetAngle(float aAngle) { return _to SetAngle(aAngle); } \
  1306.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag) { return _to GetLargeArcFlag(aLargeArcFlag); } \
  1307.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag) { return _to SetLargeArcFlag(aLargeArcFlag); } \
  1308.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag) { return _to GetSweepFlag(aSweepFlag); } \
  1309.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag) { return _to SetSweepFlag(aSweepFlag); } 
  1310.  
  1311. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1312. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGARCABS(_to) \
  1313.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  1314.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  1315.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  1316.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  1317.   NS_IMETHOD GetR1(float *aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR1(aR1); } \
  1318.   NS_IMETHOD SetR1(float aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR1(aR1); } \
  1319.   NS_IMETHOD GetR2(float *aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR2(aR2); } \
  1320.   NS_IMETHOD SetR2(float aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR2(aR2); } \
  1321.   NS_IMETHOD GetAngle(float *aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAngle(aAngle); } \
  1322.   NS_IMETHOD SetAngle(float aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAngle(aAngle); } \
  1323.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLargeArcFlag(aLargeArcFlag); } \
  1324.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetLargeArcFlag(aLargeArcFlag); } \
  1325.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSweepFlag(aSweepFlag); } \
  1326.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSweepFlag(aSweepFlag); } 
  1327.  
  1328. #if 0
  1329. /* Use the code below as a template for the implementation class for this interface. */
  1330.  
  1331. /* Header file */
  1332. class nsDOMSVGPathSegArcAbs : public nsIDOMSVGPathSegArcAbs
  1333. {
  1334. public:
  1335.   NS_DECL_ISUPPORTS
  1336.   NS_DECL_NSIDOMSVGPATHSEGARCABS
  1337.  
  1338.   nsDOMSVGPathSegArcAbs();
  1339.  
  1340. private:
  1341.   ~nsDOMSVGPathSegArcAbs();
  1342.  
  1343. protected:
  1344.   /* additional members */
  1345. };
  1346.  
  1347. /* Implementation file */
  1348. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegArcAbs, nsIDOMSVGPathSegArcAbs)
  1349.  
  1350. nsDOMSVGPathSegArcAbs::nsDOMSVGPathSegArcAbs()
  1351. {
  1352.   /* member initializers and constructor code */
  1353. }
  1354.  
  1355. nsDOMSVGPathSegArcAbs::~nsDOMSVGPathSegArcAbs()
  1356. {
  1357.   /* destructor code */
  1358. }
  1359.  
  1360. /* attribute float x; */
  1361. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetX(float *aX)
  1362. {
  1363.     return NS_ERROR_NOT_IMPLEMENTED;
  1364. }
  1365. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetX(float aX)
  1366. {
  1367.     return NS_ERROR_NOT_IMPLEMENTED;
  1368. }
  1369.  
  1370. /* attribute float y; */
  1371. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetY(float *aY)
  1372. {
  1373.     return NS_ERROR_NOT_IMPLEMENTED;
  1374. }
  1375. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetY(float aY)
  1376. {
  1377.     return NS_ERROR_NOT_IMPLEMENTED;
  1378. }
  1379.  
  1380. /* attribute float r1; */
  1381. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetR1(float *aR1)
  1382. {
  1383.     return NS_ERROR_NOT_IMPLEMENTED;
  1384. }
  1385. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetR1(float aR1)
  1386. {
  1387.     return NS_ERROR_NOT_IMPLEMENTED;
  1388. }
  1389.  
  1390. /* attribute float r2; */
  1391. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetR2(float *aR2)
  1392. {
  1393.     return NS_ERROR_NOT_IMPLEMENTED;
  1394. }
  1395. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetR2(float aR2)
  1396. {
  1397.     return NS_ERROR_NOT_IMPLEMENTED;
  1398. }
  1399.  
  1400. /* attribute float angle; */
  1401. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetAngle(float *aAngle)
  1402. {
  1403.     return NS_ERROR_NOT_IMPLEMENTED;
  1404. }
  1405. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetAngle(float aAngle)
  1406. {
  1407.     return NS_ERROR_NOT_IMPLEMENTED;
  1408. }
  1409.  
  1410. /* attribute boolean largeArcFlag; */
  1411. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetLargeArcFlag(PRBool *aLargeArcFlag)
  1412. {
  1413.     return NS_ERROR_NOT_IMPLEMENTED;
  1414. }
  1415. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetLargeArcFlag(PRBool aLargeArcFlag)
  1416. {
  1417.     return NS_ERROR_NOT_IMPLEMENTED;
  1418. }
  1419.  
  1420. /* attribute boolean sweepFlag; */
  1421. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::GetSweepFlag(PRBool *aSweepFlag)
  1422. {
  1423.     return NS_ERROR_NOT_IMPLEMENTED;
  1424. }
  1425. NS_IMETHODIMP nsDOMSVGPathSegArcAbs::SetSweepFlag(PRBool aSweepFlag)
  1426. {
  1427.     return NS_ERROR_NOT_IMPLEMENTED;
  1428. }
  1429.  
  1430. /* End of implementation class template. */
  1431. #endif
  1432.  
  1433.  
  1434. /* starting interface:    nsIDOMSVGPathSegArcRel */
  1435. #define NS_IDOMSVGPATHSEGARCREL_IID_STR "a685997e-fb47-47c0-a34c-5da11cb66537"
  1436.  
  1437. #define NS_IDOMSVGPATHSEGARCREL_IID \
  1438.   {0xa685997e, 0xfb47, 0x47c0, \
  1439.     { 0xa3, 0x4c, 0x5d, 0xa1, 0x1c, 0xb6, 0x65, 0x37 }}
  1440.  
  1441. class NS_NO_VTABLE nsIDOMSVGPathSegArcRel : public nsIDOMSVGPathSeg {
  1442.  public: 
  1443.  
  1444.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGARCREL_IID)
  1445.  
  1446.   /* attribute float x; */
  1447.   NS_IMETHOD GetX(float *aX) = 0;
  1448.   NS_IMETHOD SetX(float aX) = 0;
  1449.  
  1450.   /* attribute float y; */
  1451.   NS_IMETHOD GetY(float *aY) = 0;
  1452.   NS_IMETHOD SetY(float aY) = 0;
  1453.  
  1454.   /* attribute float r1; */
  1455.   NS_IMETHOD GetR1(float *aR1) = 0;
  1456.   NS_IMETHOD SetR1(float aR1) = 0;
  1457.  
  1458.   /* attribute float r2; */
  1459.   NS_IMETHOD GetR2(float *aR2) = 0;
  1460.   NS_IMETHOD SetR2(float aR2) = 0;
  1461.  
  1462.   /* attribute float angle; */
  1463.   NS_IMETHOD GetAngle(float *aAngle) = 0;
  1464.   NS_IMETHOD SetAngle(float aAngle) = 0;
  1465.  
  1466.   /* attribute boolean largeArcFlag; */
  1467.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag) = 0;
  1468.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag) = 0;
  1469.  
  1470.   /* attribute boolean sweepFlag; */
  1471.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag) = 0;
  1472.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag) = 0;
  1473.  
  1474. };
  1475.  
  1476. /* Use this macro when declaring classes that implement this interface. */
  1477. #define NS_DECL_NSIDOMSVGPATHSEGARCREL \
  1478.   NS_IMETHOD GetX(float *aX); \
  1479.   NS_IMETHOD SetX(float aX); \
  1480.   NS_IMETHOD GetY(float *aY); \
  1481.   NS_IMETHOD SetY(float aY); \
  1482.   NS_IMETHOD GetR1(float *aR1); \
  1483.   NS_IMETHOD SetR1(float aR1); \
  1484.   NS_IMETHOD GetR2(float *aR2); \
  1485.   NS_IMETHOD SetR2(float aR2); \
  1486.   NS_IMETHOD GetAngle(float *aAngle); \
  1487.   NS_IMETHOD SetAngle(float aAngle); \
  1488.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag); \
  1489.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag); \
  1490.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag); \
  1491.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag); 
  1492.  
  1493. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1494. #define NS_FORWARD_NSIDOMSVGPATHSEGARCREL(_to) \
  1495.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1496.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  1497.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1498.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  1499.   NS_IMETHOD GetR1(float *aR1) { return _to GetR1(aR1); } \
  1500.   NS_IMETHOD SetR1(float aR1) { return _to SetR1(aR1); } \
  1501.   NS_IMETHOD GetR2(float *aR2) { return _to GetR2(aR2); } \
  1502.   NS_IMETHOD SetR2(float aR2) { return _to SetR2(aR2); } \
  1503.   NS_IMETHOD GetAngle(float *aAngle) { return _to GetAngle(aAngle); } \
  1504.   NS_IMETHOD SetAngle(float aAngle) { return _to SetAngle(aAngle); } \
  1505.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag) { return _to GetLargeArcFlag(aLargeArcFlag); } \
  1506.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag) { return _to SetLargeArcFlag(aLargeArcFlag); } \
  1507.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag) { return _to GetSweepFlag(aSweepFlag); } \
  1508.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag) { return _to SetSweepFlag(aSweepFlag); } 
  1509.  
  1510. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1511. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGARCREL(_to) \
  1512.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  1513.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  1514.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  1515.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  1516.   NS_IMETHOD GetR1(float *aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR1(aR1); } \
  1517.   NS_IMETHOD SetR1(float aR1) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR1(aR1); } \
  1518.   NS_IMETHOD GetR2(float *aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetR2(aR2); } \
  1519.   NS_IMETHOD SetR2(float aR2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetR2(aR2); } \
  1520.   NS_IMETHOD GetAngle(float *aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAngle(aAngle); } \
  1521.   NS_IMETHOD SetAngle(float aAngle) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAngle(aAngle); } \
  1522.   NS_IMETHOD GetLargeArcFlag(PRBool *aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetLargeArcFlag(aLargeArcFlag); } \
  1523.   NS_IMETHOD SetLargeArcFlag(PRBool aLargeArcFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetLargeArcFlag(aLargeArcFlag); } \
  1524.   NS_IMETHOD GetSweepFlag(PRBool *aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSweepFlag(aSweepFlag); } \
  1525.   NS_IMETHOD SetSweepFlag(PRBool aSweepFlag) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSweepFlag(aSweepFlag); } 
  1526.  
  1527. #if 0
  1528. /* Use the code below as a template for the implementation class for this interface. */
  1529.  
  1530. /* Header file */
  1531. class nsDOMSVGPathSegArcRel : public nsIDOMSVGPathSegArcRel
  1532. {
  1533. public:
  1534.   NS_DECL_ISUPPORTS
  1535.   NS_DECL_NSIDOMSVGPATHSEGARCREL
  1536.  
  1537.   nsDOMSVGPathSegArcRel();
  1538.  
  1539. private:
  1540.   ~nsDOMSVGPathSegArcRel();
  1541.  
  1542. protected:
  1543.   /* additional members */
  1544. };
  1545.  
  1546. /* Implementation file */
  1547. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegArcRel, nsIDOMSVGPathSegArcRel)
  1548.  
  1549. nsDOMSVGPathSegArcRel::nsDOMSVGPathSegArcRel()
  1550. {
  1551.   /* member initializers and constructor code */
  1552. }
  1553.  
  1554. nsDOMSVGPathSegArcRel::~nsDOMSVGPathSegArcRel()
  1555. {
  1556.   /* destructor code */
  1557. }
  1558.  
  1559. /* attribute float x; */
  1560. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetX(float *aX)
  1561. {
  1562.     return NS_ERROR_NOT_IMPLEMENTED;
  1563. }
  1564. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetX(float aX)
  1565. {
  1566.     return NS_ERROR_NOT_IMPLEMENTED;
  1567. }
  1568.  
  1569. /* attribute float y; */
  1570. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetY(float *aY)
  1571. {
  1572.     return NS_ERROR_NOT_IMPLEMENTED;
  1573. }
  1574. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetY(float aY)
  1575. {
  1576.     return NS_ERROR_NOT_IMPLEMENTED;
  1577. }
  1578.  
  1579. /* attribute float r1; */
  1580. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetR1(float *aR1)
  1581. {
  1582.     return NS_ERROR_NOT_IMPLEMENTED;
  1583. }
  1584. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetR1(float aR1)
  1585. {
  1586.     return NS_ERROR_NOT_IMPLEMENTED;
  1587. }
  1588.  
  1589. /* attribute float r2; */
  1590. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetR2(float *aR2)
  1591. {
  1592.     return NS_ERROR_NOT_IMPLEMENTED;
  1593. }
  1594. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetR2(float aR2)
  1595. {
  1596.     return NS_ERROR_NOT_IMPLEMENTED;
  1597. }
  1598.  
  1599. /* attribute float angle; */
  1600. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetAngle(float *aAngle)
  1601. {
  1602.     return NS_ERROR_NOT_IMPLEMENTED;
  1603. }
  1604. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetAngle(float aAngle)
  1605. {
  1606.     return NS_ERROR_NOT_IMPLEMENTED;
  1607. }
  1608.  
  1609. /* attribute boolean largeArcFlag; */
  1610. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetLargeArcFlag(PRBool *aLargeArcFlag)
  1611. {
  1612.     return NS_ERROR_NOT_IMPLEMENTED;
  1613. }
  1614. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetLargeArcFlag(PRBool aLargeArcFlag)
  1615. {
  1616.     return NS_ERROR_NOT_IMPLEMENTED;
  1617. }
  1618.  
  1619. /* attribute boolean sweepFlag; */
  1620. NS_IMETHODIMP nsDOMSVGPathSegArcRel::GetSweepFlag(PRBool *aSweepFlag)
  1621. {
  1622.     return NS_ERROR_NOT_IMPLEMENTED;
  1623. }
  1624. NS_IMETHODIMP nsDOMSVGPathSegArcRel::SetSweepFlag(PRBool aSweepFlag)
  1625. {
  1626.     return NS_ERROR_NOT_IMPLEMENTED;
  1627. }
  1628.  
  1629. /* End of implementation class template. */
  1630. #endif
  1631.  
  1632.  
  1633. /* starting interface:    nsIDOMSVGPathSegLinetoHorizontalAbs */
  1634. #define NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID_STR "e74b55ef-1c44-4a40-9f51-a2196b11283a"
  1635.  
  1636. #define NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID \
  1637.   {0xe74b55ef, 0x1c44, 0x4a40, \
  1638.     { 0x9f, 0x51, 0xa2, 0x19, 0x6b, 0x11, 0x28, 0x3a }}
  1639.  
  1640. class NS_NO_VTABLE nsIDOMSVGPathSegLinetoHorizontalAbs : public nsIDOMSVGPathSeg {
  1641.  public: 
  1642.  
  1643.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOHORIZONTALABS_IID)
  1644.  
  1645.   /* attribute float x; */
  1646.   NS_IMETHOD GetX(float *aX) = 0;
  1647.   NS_IMETHOD SetX(float aX) = 0;
  1648.  
  1649. };
  1650.  
  1651. /* Use this macro when declaring classes that implement this interface. */
  1652. #define NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALABS \
  1653.   NS_IMETHOD GetX(float *aX); \
  1654.   NS_IMETHOD SetX(float aX); 
  1655.  
  1656. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1657. #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOHORIZONTALABS(_to) \
  1658.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1659.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } 
  1660.  
  1661. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1662. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOHORIZONTALABS(_to) \
  1663.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  1664.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } 
  1665.  
  1666. #if 0
  1667. /* Use the code below as a template for the implementation class for this interface. */
  1668.  
  1669. /* Header file */
  1670. class nsDOMSVGPathSegLinetoHorizontalAbs : public nsIDOMSVGPathSegLinetoHorizontalAbs
  1671. {
  1672. public:
  1673.   NS_DECL_ISUPPORTS
  1674.   NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALABS
  1675.  
  1676.   nsDOMSVGPathSegLinetoHorizontalAbs();
  1677.  
  1678. private:
  1679.   ~nsDOMSVGPathSegLinetoHorizontalAbs();
  1680.  
  1681. protected:
  1682.   /* additional members */
  1683. };
  1684.  
  1685. /* Implementation file */
  1686. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoHorizontalAbs, nsIDOMSVGPathSegLinetoHorizontalAbs)
  1687.  
  1688. nsDOMSVGPathSegLinetoHorizontalAbs::nsDOMSVGPathSegLinetoHorizontalAbs()
  1689. {
  1690.   /* member initializers and constructor code */
  1691. }
  1692.  
  1693. nsDOMSVGPathSegLinetoHorizontalAbs::~nsDOMSVGPathSegLinetoHorizontalAbs()
  1694. {
  1695.   /* destructor code */
  1696. }
  1697.  
  1698. /* attribute float x; */
  1699. NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalAbs::GetX(float *aX)
  1700. {
  1701.     return NS_ERROR_NOT_IMPLEMENTED;
  1702. }
  1703. NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalAbs::SetX(float aX)
  1704. {
  1705.     return NS_ERROR_NOT_IMPLEMENTED;
  1706. }
  1707.  
  1708. /* End of implementation class template. */
  1709. #endif
  1710.  
  1711.  
  1712. /* starting interface:    nsIDOMSVGPathSegLinetoHorizontalRel */
  1713. #define NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID_STR "0a797fdc-8b60-4cb3-a0da-4c898832ba30"
  1714.  
  1715. #define NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID \
  1716.   {0x0a797fdc, 0x8b60, 0x4cb3, \
  1717.     { 0xa0, 0xda, 0x4c, 0x89, 0x88, 0x32, 0xba, 0x30 }}
  1718.  
  1719. class NS_NO_VTABLE nsIDOMSVGPathSegLinetoHorizontalRel : public nsIDOMSVGPathSeg {
  1720.  public: 
  1721.  
  1722.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOHORIZONTALREL_IID)
  1723.  
  1724.   /* attribute float x; */
  1725.   NS_IMETHOD GetX(float *aX) = 0;
  1726.   NS_IMETHOD SetX(float aX) = 0;
  1727.  
  1728. };
  1729.  
  1730. /* Use this macro when declaring classes that implement this interface. */
  1731. #define NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALREL \
  1732.   NS_IMETHOD GetX(float *aX); \
  1733.   NS_IMETHOD SetX(float aX); 
  1734.  
  1735. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1736. #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOHORIZONTALREL(_to) \
  1737.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1738.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } 
  1739.  
  1740. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1741. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOHORIZONTALREL(_to) \
  1742.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  1743.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } 
  1744.  
  1745. #if 0
  1746. /* Use the code below as a template for the implementation class for this interface. */
  1747.  
  1748. /* Header file */
  1749. class nsDOMSVGPathSegLinetoHorizontalRel : public nsIDOMSVGPathSegLinetoHorizontalRel
  1750. {
  1751. public:
  1752.   NS_DECL_ISUPPORTS
  1753.   NS_DECL_NSIDOMSVGPATHSEGLINETOHORIZONTALREL
  1754.  
  1755.   nsDOMSVGPathSegLinetoHorizontalRel();
  1756.  
  1757. private:
  1758.   ~nsDOMSVGPathSegLinetoHorizontalRel();
  1759.  
  1760. protected:
  1761.   /* additional members */
  1762. };
  1763.  
  1764. /* Implementation file */
  1765. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoHorizontalRel, nsIDOMSVGPathSegLinetoHorizontalRel)
  1766.  
  1767. nsDOMSVGPathSegLinetoHorizontalRel::nsDOMSVGPathSegLinetoHorizontalRel()
  1768. {
  1769.   /* member initializers and constructor code */
  1770. }
  1771.  
  1772. nsDOMSVGPathSegLinetoHorizontalRel::~nsDOMSVGPathSegLinetoHorizontalRel()
  1773. {
  1774.   /* destructor code */
  1775. }
  1776.  
  1777. /* attribute float x; */
  1778. NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalRel::GetX(float *aX)
  1779. {
  1780.     return NS_ERROR_NOT_IMPLEMENTED;
  1781. }
  1782. NS_IMETHODIMP nsDOMSVGPathSegLinetoHorizontalRel::SetX(float aX)
  1783. {
  1784.     return NS_ERROR_NOT_IMPLEMENTED;
  1785. }
  1786.  
  1787. /* End of implementation class template. */
  1788. #endif
  1789.  
  1790.  
  1791. /* starting interface:    nsIDOMSVGPathSegLinetoVerticalAbs */
  1792. #define NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID_STR "0811d434-3d90-4eec-8fa2-066dde037917"
  1793.  
  1794. #define NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID \
  1795.   {0x0811d434, 0x3d90, 0x4eec, \
  1796.     { 0x8f, 0xa2, 0x06, 0x6d, 0xde, 0x03, 0x79, 0x17 }}
  1797.  
  1798. class NS_NO_VTABLE nsIDOMSVGPathSegLinetoVerticalAbs : public nsIDOMSVGPathSeg {
  1799.  public: 
  1800.  
  1801.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOVERTICALABS_IID)
  1802.  
  1803.   /* attribute float y; */
  1804.   NS_IMETHOD GetY(float *aY) = 0;
  1805.   NS_IMETHOD SetY(float aY) = 0;
  1806.  
  1807. };
  1808.  
  1809. /* Use this macro when declaring classes that implement this interface. */
  1810. #define NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALABS \
  1811.   NS_IMETHOD GetY(float *aY); \
  1812.   NS_IMETHOD SetY(float aY); 
  1813.  
  1814. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1815. #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOVERTICALABS(_to) \
  1816.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1817.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  1818.  
  1819. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1820. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOVERTICALABS(_to) \
  1821.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  1822.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  1823.  
  1824. #if 0
  1825. /* Use the code below as a template for the implementation class for this interface. */
  1826.  
  1827. /* Header file */
  1828. class nsDOMSVGPathSegLinetoVerticalAbs : public nsIDOMSVGPathSegLinetoVerticalAbs
  1829. {
  1830. public:
  1831.   NS_DECL_ISUPPORTS
  1832.   NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALABS
  1833.  
  1834.   nsDOMSVGPathSegLinetoVerticalAbs();
  1835.  
  1836. private:
  1837.   ~nsDOMSVGPathSegLinetoVerticalAbs();
  1838.  
  1839. protected:
  1840.   /* additional members */
  1841. };
  1842.  
  1843. /* Implementation file */
  1844. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoVerticalAbs, nsIDOMSVGPathSegLinetoVerticalAbs)
  1845.  
  1846. nsDOMSVGPathSegLinetoVerticalAbs::nsDOMSVGPathSegLinetoVerticalAbs()
  1847. {
  1848.   /* member initializers and constructor code */
  1849. }
  1850.  
  1851. nsDOMSVGPathSegLinetoVerticalAbs::~nsDOMSVGPathSegLinetoVerticalAbs()
  1852. {
  1853.   /* destructor code */
  1854. }
  1855.  
  1856. /* attribute float y; */
  1857. NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalAbs::GetY(float *aY)
  1858. {
  1859.     return NS_ERROR_NOT_IMPLEMENTED;
  1860. }
  1861. NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalAbs::SetY(float aY)
  1862. {
  1863.     return NS_ERROR_NOT_IMPLEMENTED;
  1864. }
  1865.  
  1866. /* End of implementation class template. */
  1867. #endif
  1868.  
  1869.  
  1870. /* starting interface:    nsIDOMSVGPathSegLinetoVerticalRel */
  1871. #define NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID_STR "93db35b1-6b33-49d5-ad25-1ed1a7611ad2"
  1872.  
  1873. #define NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID \
  1874.   {0x93db35b1, 0x6b33, 0x49d5, \
  1875.     { 0xad, 0x25, 0x1e, 0xd1, 0xa7, 0x61, 0x1a, 0xd2 }}
  1876.  
  1877. class NS_NO_VTABLE nsIDOMSVGPathSegLinetoVerticalRel : public nsIDOMSVGPathSeg {
  1878.  public: 
  1879.  
  1880.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGLINETOVERTICALREL_IID)
  1881.  
  1882.   /* attribute float y; */
  1883.   NS_IMETHOD GetY(float *aY) = 0;
  1884.   NS_IMETHOD SetY(float aY) = 0;
  1885.  
  1886. };
  1887.  
  1888. /* Use this macro when declaring classes that implement this interface. */
  1889. #define NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALREL \
  1890.   NS_IMETHOD GetY(float *aY); \
  1891.   NS_IMETHOD SetY(float aY); 
  1892.  
  1893. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1894. #define NS_FORWARD_NSIDOMSVGPATHSEGLINETOVERTICALREL(_to) \
  1895.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1896.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  1897.  
  1898. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  1899. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGLINETOVERTICALREL(_to) \
  1900.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  1901.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  1902.  
  1903. #if 0
  1904. /* Use the code below as a template for the implementation class for this interface. */
  1905.  
  1906. /* Header file */
  1907. class nsDOMSVGPathSegLinetoVerticalRel : public nsIDOMSVGPathSegLinetoVerticalRel
  1908. {
  1909. public:
  1910.   NS_DECL_ISUPPORTS
  1911.   NS_DECL_NSIDOMSVGPATHSEGLINETOVERTICALREL
  1912.  
  1913.   nsDOMSVGPathSegLinetoVerticalRel();
  1914.  
  1915. private:
  1916.   ~nsDOMSVGPathSegLinetoVerticalRel();
  1917.  
  1918. protected:
  1919.   /* additional members */
  1920. };
  1921.  
  1922. /* Implementation file */
  1923. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegLinetoVerticalRel, nsIDOMSVGPathSegLinetoVerticalRel)
  1924.  
  1925. nsDOMSVGPathSegLinetoVerticalRel::nsDOMSVGPathSegLinetoVerticalRel()
  1926. {
  1927.   /* member initializers and constructor code */
  1928. }
  1929.  
  1930. nsDOMSVGPathSegLinetoVerticalRel::~nsDOMSVGPathSegLinetoVerticalRel()
  1931. {
  1932.   /* destructor code */
  1933. }
  1934.  
  1935. /* attribute float y; */
  1936. NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalRel::GetY(float *aY)
  1937. {
  1938.     return NS_ERROR_NOT_IMPLEMENTED;
  1939. }
  1940. NS_IMETHODIMP nsDOMSVGPathSegLinetoVerticalRel::SetY(float aY)
  1941. {
  1942.     return NS_ERROR_NOT_IMPLEMENTED;
  1943. }
  1944.  
  1945. /* End of implementation class template. */
  1946. #endif
  1947.  
  1948.  
  1949. /* starting interface:    nsIDOMSVGPathSegCurvetoCubicSmoothAbs */
  1950. #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID_STR "eb422132-514e-4a1c-81ec-b84a5df5fb96"
  1951.  
  1952. #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID \
  1953.   {0xeb422132, 0x514e, 0x4a1c, \
  1954.     { 0x81, 0xec, 0xb8, 0x4a, 0x5d, 0xf5, 0xfb, 0x96 }}
  1955.  
  1956. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoCubicSmoothAbs : public nsIDOMSVGPathSeg {
  1957.  public: 
  1958.  
  1959.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHABS_IID)
  1960.  
  1961.   /* attribute float x; */
  1962.   NS_IMETHOD GetX(float *aX) = 0;
  1963.   NS_IMETHOD SetX(float aX) = 0;
  1964.  
  1965.   /* attribute float y; */
  1966.   NS_IMETHOD GetY(float *aY) = 0;
  1967.   NS_IMETHOD SetY(float aY) = 0;
  1968.  
  1969.   /* attribute float x2; */
  1970.   NS_IMETHOD GetX2(float *aX2) = 0;
  1971.   NS_IMETHOD SetX2(float aX2) = 0;
  1972.  
  1973.   /* attribute float y2; */
  1974.   NS_IMETHOD GetY2(float *aY2) = 0;
  1975.   NS_IMETHOD SetY2(float aY2) = 0;
  1976.  
  1977. };
  1978.  
  1979. /* Use this macro when declaring classes that implement this interface. */
  1980. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS \
  1981.   NS_IMETHOD GetX(float *aX); \
  1982.   NS_IMETHOD SetX(float aX); \
  1983.   NS_IMETHOD GetY(float *aY); \
  1984.   NS_IMETHOD SetY(float aY); \
  1985.   NS_IMETHOD GetX2(float *aX2); \
  1986.   NS_IMETHOD SetX2(float aX2); \
  1987.   NS_IMETHOD GetY2(float *aY2); \
  1988.   NS_IMETHOD SetY2(float aY2); 
  1989.  
  1990. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  1991. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS(_to) \
  1992.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  1993.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  1994.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  1995.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  1996.   NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
  1997.   NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
  1998.   NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
  1999.   NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); } 
  2000.  
  2001. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  2002. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS(_to) \
  2003.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  2004.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  2005.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  2006.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  2007.   NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
  2008.   NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
  2009.   NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
  2010.   NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); } 
  2011.  
  2012. #if 0
  2013. /* Use the code below as a template for the implementation class for this interface. */
  2014.  
  2015. /* Header file */
  2016. class nsDOMSVGPathSegCurvetoCubicSmoothAbs : public nsIDOMSVGPathSegCurvetoCubicSmoothAbs
  2017. {
  2018. public:
  2019.   NS_DECL_ISUPPORTS
  2020.   NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHABS
  2021.  
  2022.   nsDOMSVGPathSegCurvetoCubicSmoothAbs();
  2023.  
  2024. private:
  2025.   ~nsDOMSVGPathSegCurvetoCubicSmoothAbs();
  2026.  
  2027. protected:
  2028.   /* additional members */
  2029. };
  2030.  
  2031. /* Implementation file */
  2032. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicSmoothAbs, nsIDOMSVGPathSegCurvetoCubicSmoothAbs)
  2033.  
  2034. nsDOMSVGPathSegCurvetoCubicSmoothAbs::nsDOMSVGPathSegCurvetoCubicSmoothAbs()
  2035. {
  2036.   /* member initializers and constructor code */
  2037. }
  2038.  
  2039. nsDOMSVGPathSegCurvetoCubicSmoothAbs::~nsDOMSVGPathSegCurvetoCubicSmoothAbs()
  2040. {
  2041.   /* destructor code */
  2042. }
  2043.  
  2044. /* attribute float x; */
  2045. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetX(float *aX)
  2046. {
  2047.     return NS_ERROR_NOT_IMPLEMENTED;
  2048. }
  2049. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetX(float aX)
  2050. {
  2051.     return NS_ERROR_NOT_IMPLEMENTED;
  2052. }
  2053.  
  2054. /* attribute float y; */
  2055. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetY(float *aY)
  2056. {
  2057.     return NS_ERROR_NOT_IMPLEMENTED;
  2058. }
  2059. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetY(float aY)
  2060. {
  2061.     return NS_ERROR_NOT_IMPLEMENTED;
  2062. }
  2063.  
  2064. /* attribute float x2; */
  2065. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetX2(float *aX2)
  2066. {
  2067.     return NS_ERROR_NOT_IMPLEMENTED;
  2068. }
  2069. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetX2(float aX2)
  2070. {
  2071.     return NS_ERROR_NOT_IMPLEMENTED;
  2072. }
  2073.  
  2074. /* attribute float y2; */
  2075. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::GetY2(float *aY2)
  2076. {
  2077.     return NS_ERROR_NOT_IMPLEMENTED;
  2078. }
  2079. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothAbs::SetY2(float aY2)
  2080. {
  2081.     return NS_ERROR_NOT_IMPLEMENTED;
  2082. }
  2083.  
  2084. /* End of implementation class template. */
  2085. #endif
  2086.  
  2087.  
  2088. /* starting interface:    nsIDOMSVGPathSegCurvetoCubicSmoothRel */
  2089. #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID_STR "5860bccd-f86b-47f8-86c1-cb1245b6a8e1"
  2090.  
  2091. #define NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID \
  2092.   {0x5860bccd, 0xf86b, 0x47f8, \
  2093.     { 0x86, 0xc1, 0xcb, 0x12, 0x45, 0xb6, 0xa8, 0xe1 }}
  2094.  
  2095. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoCubicSmoothRel : public nsIDOMSVGPathSeg {
  2096.  public: 
  2097.  
  2098.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOCUBICSMOOTHREL_IID)
  2099.  
  2100.   /* attribute float x; */
  2101.   NS_IMETHOD GetX(float *aX) = 0;
  2102.   NS_IMETHOD SetX(float aX) = 0;
  2103.  
  2104.   /* attribute float y; */
  2105.   NS_IMETHOD GetY(float *aY) = 0;
  2106.   NS_IMETHOD SetY(float aY) = 0;
  2107.  
  2108.   /* attribute float x2; */
  2109.   NS_IMETHOD GetX2(float *aX2) = 0;
  2110.   NS_IMETHOD SetX2(float aX2) = 0;
  2111.  
  2112.   /* attribute float y2; */
  2113.   NS_IMETHOD GetY2(float *aY2) = 0;
  2114.   NS_IMETHOD SetY2(float aY2) = 0;
  2115.  
  2116. };
  2117.  
  2118. /* Use this macro when declaring classes that implement this interface. */
  2119. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL \
  2120.   NS_IMETHOD GetX(float *aX); \
  2121.   NS_IMETHOD SetX(float aX); \
  2122.   NS_IMETHOD GetY(float *aY); \
  2123.   NS_IMETHOD SetY(float aY); \
  2124.   NS_IMETHOD GetX2(float *aX2); \
  2125.   NS_IMETHOD SetX2(float aX2); \
  2126.   NS_IMETHOD GetY2(float *aY2); \
  2127.   NS_IMETHOD SetY2(float aY2); 
  2128.  
  2129. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  2130. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL(_to) \
  2131.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  2132.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  2133.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  2134.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } \
  2135.   NS_IMETHOD GetX2(float *aX2) { return _to GetX2(aX2); } \
  2136.   NS_IMETHOD SetX2(float aX2) { return _to SetX2(aX2); } \
  2137.   NS_IMETHOD GetY2(float *aY2) { return _to GetY2(aY2); } \
  2138.   NS_IMETHOD SetY2(float aY2) { return _to SetY2(aY2); } 
  2139.  
  2140. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  2141. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL(_to) \
  2142.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  2143.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  2144.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  2145.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } \
  2146.   NS_IMETHOD GetX2(float *aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX2(aX2); } \
  2147.   NS_IMETHOD SetX2(float aX2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX2(aX2); } \
  2148.   NS_IMETHOD GetY2(float *aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY2(aY2); } \
  2149.   NS_IMETHOD SetY2(float aY2) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY2(aY2); } 
  2150.  
  2151. #if 0
  2152. /* Use the code below as a template for the implementation class for this interface. */
  2153.  
  2154. /* Header file */
  2155. class nsDOMSVGPathSegCurvetoCubicSmoothRel : public nsIDOMSVGPathSegCurvetoCubicSmoothRel
  2156. {
  2157. public:
  2158.   NS_DECL_ISUPPORTS
  2159.   NS_DECL_NSIDOMSVGPATHSEGCURVETOCUBICSMOOTHREL
  2160.  
  2161.   nsDOMSVGPathSegCurvetoCubicSmoothRel();
  2162.  
  2163. private:
  2164.   ~nsDOMSVGPathSegCurvetoCubicSmoothRel();
  2165.  
  2166. protected:
  2167.   /* additional members */
  2168. };
  2169.  
  2170. /* Implementation file */
  2171. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoCubicSmoothRel, nsIDOMSVGPathSegCurvetoCubicSmoothRel)
  2172.  
  2173. nsDOMSVGPathSegCurvetoCubicSmoothRel::nsDOMSVGPathSegCurvetoCubicSmoothRel()
  2174. {
  2175.   /* member initializers and constructor code */
  2176. }
  2177.  
  2178. nsDOMSVGPathSegCurvetoCubicSmoothRel::~nsDOMSVGPathSegCurvetoCubicSmoothRel()
  2179. {
  2180.   /* destructor code */
  2181. }
  2182.  
  2183. /* attribute float x; */
  2184. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetX(float *aX)
  2185. {
  2186.     return NS_ERROR_NOT_IMPLEMENTED;
  2187. }
  2188. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetX(float aX)
  2189. {
  2190.     return NS_ERROR_NOT_IMPLEMENTED;
  2191. }
  2192.  
  2193. /* attribute float y; */
  2194. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetY(float *aY)
  2195. {
  2196.     return NS_ERROR_NOT_IMPLEMENTED;
  2197. }
  2198. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetY(float aY)
  2199. {
  2200.     return NS_ERROR_NOT_IMPLEMENTED;
  2201. }
  2202.  
  2203. /* attribute float x2; */
  2204. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetX2(float *aX2)
  2205. {
  2206.     return NS_ERROR_NOT_IMPLEMENTED;
  2207. }
  2208. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetX2(float aX2)
  2209. {
  2210.     return NS_ERROR_NOT_IMPLEMENTED;
  2211. }
  2212.  
  2213. /* attribute float y2; */
  2214. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::GetY2(float *aY2)
  2215. {
  2216.     return NS_ERROR_NOT_IMPLEMENTED;
  2217. }
  2218. NS_IMETHODIMP nsDOMSVGPathSegCurvetoCubicSmoothRel::SetY2(float aY2)
  2219. {
  2220.     return NS_ERROR_NOT_IMPLEMENTED;
  2221. }
  2222.  
  2223. /* End of implementation class template. */
  2224. #endif
  2225.  
  2226.  
  2227. /* starting interface:    nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs */
  2228. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID_STR "3ce86063-0a35-48ec-b372-f198b7d04755"
  2229.  
  2230. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID \
  2231.   {0x3ce86063, 0x0a35, 0x48ec, \
  2232.     { 0xb3, 0x72, 0xf1, 0x98, 0xb7, 0xd0, 0x47, 0x55 }}
  2233.  
  2234. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs : public nsIDOMSVGPathSeg {
  2235.  public: 
  2236.  
  2237.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS_IID)
  2238.  
  2239.   /* attribute float x; */
  2240.   NS_IMETHOD GetX(float *aX) = 0;
  2241.   NS_IMETHOD SetX(float aX) = 0;
  2242.  
  2243.   /* attribute float y; */
  2244.   NS_IMETHOD GetY(float *aY) = 0;
  2245.   NS_IMETHOD SetY(float aY) = 0;
  2246.  
  2247. };
  2248.  
  2249. /* Use this macro when declaring classes that implement this interface. */
  2250. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS \
  2251.   NS_IMETHOD GetX(float *aX); \
  2252.   NS_IMETHOD SetX(float aX); \
  2253.   NS_IMETHOD GetY(float *aY); \
  2254.   NS_IMETHOD SetY(float aY); 
  2255.  
  2256. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  2257. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS(_to) \
  2258.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  2259.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  2260.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  2261.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  2262.  
  2263. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  2264. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS(_to) \
  2265.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  2266.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  2267.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  2268.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  2269.  
  2270. #if 0
  2271. /* Use the code below as a template for the implementation class for this interface. */
  2272.  
  2273. /* Header file */
  2274. class nsDOMSVGPathSegCurvetoQuadraticSmoothAbs : public nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs
  2275. {
  2276. public:
  2277.   NS_DECL_ISUPPORTS
  2278.   NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHABS
  2279.  
  2280.   nsDOMSVGPathSegCurvetoQuadraticSmoothAbs();
  2281.  
  2282. private:
  2283.   ~nsDOMSVGPathSegCurvetoQuadraticSmoothAbs();
  2284.  
  2285. protected:
  2286.   /* additional members */
  2287. };
  2288.  
  2289. /* Implementation file */
  2290. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticSmoothAbs, nsIDOMSVGPathSegCurvetoQuadraticSmoothAbs)
  2291.  
  2292. nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::nsDOMSVGPathSegCurvetoQuadraticSmoothAbs()
  2293. {
  2294.   /* member initializers and constructor code */
  2295. }
  2296.  
  2297. nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::~nsDOMSVGPathSegCurvetoQuadraticSmoothAbs()
  2298. {
  2299.   /* destructor code */
  2300. }
  2301.  
  2302. /* attribute float x; */
  2303. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::GetX(float *aX)
  2304. {
  2305.     return NS_ERROR_NOT_IMPLEMENTED;
  2306. }
  2307. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::SetX(float aX)
  2308. {
  2309.     return NS_ERROR_NOT_IMPLEMENTED;
  2310. }
  2311.  
  2312. /* attribute float y; */
  2313. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::GetY(float *aY)
  2314. {
  2315.     return NS_ERROR_NOT_IMPLEMENTED;
  2316. }
  2317. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothAbs::SetY(float aY)
  2318. {
  2319.     return NS_ERROR_NOT_IMPLEMENTED;
  2320. }
  2321.  
  2322. /* End of implementation class template. */
  2323. #endif
  2324.  
  2325.  
  2326. /* starting interface:    nsIDOMSVGPathSegCurvetoQuadraticSmoothRel */
  2327. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID_STR "5c0e4d25-a9f1-4aab-936c-2b61ed6c085f"
  2328.  
  2329. #define NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID \
  2330.   {0x5c0e4d25, 0xa9f1, 0x4aab, \
  2331.     { 0x93, 0x6c, 0x2b, 0x61, 0xed, 0x6c, 0x08, 0x5f }}
  2332.  
  2333. class NS_NO_VTABLE nsIDOMSVGPathSegCurvetoQuadraticSmoothRel : public nsIDOMSVGPathSeg {
  2334.  public: 
  2335.  
  2336.   NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL_IID)
  2337.  
  2338.   /* attribute float x; */
  2339.   NS_IMETHOD GetX(float *aX) = 0;
  2340.   NS_IMETHOD SetX(float aX) = 0;
  2341.  
  2342.   /* attribute float y; */
  2343.   NS_IMETHOD GetY(float *aY) = 0;
  2344.   NS_IMETHOD SetY(float aY) = 0;
  2345.  
  2346. };
  2347.  
  2348. /* Use this macro when declaring classes that implement this interface. */
  2349. #define NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL \
  2350.   NS_IMETHOD GetX(float *aX); \
  2351.   NS_IMETHOD SetX(float aX); \
  2352.   NS_IMETHOD GetY(float *aY); \
  2353.   NS_IMETHOD SetY(float aY); 
  2354.  
  2355. /* Use this macro to declare functions that forward the behavior of this interface to another object. */
  2356. #define NS_FORWARD_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL(_to) \
  2357.   NS_IMETHOD GetX(float *aX) { return _to GetX(aX); } \
  2358.   NS_IMETHOD SetX(float aX) { return _to SetX(aX); } \
  2359.   NS_IMETHOD GetY(float *aY) { return _to GetY(aY); } \
  2360.   NS_IMETHOD SetY(float aY) { return _to SetY(aY); } 
  2361.  
  2362. /* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
  2363. #define NS_FORWARD_SAFE_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL(_to) \
  2364.   NS_IMETHOD GetX(float *aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetX(aX); } \
  2365.   NS_IMETHOD SetX(float aX) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetX(aX); } \
  2366.   NS_IMETHOD GetY(float *aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetY(aY); } \
  2367.   NS_IMETHOD SetY(float aY) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetY(aY); } 
  2368.  
  2369. #if 0
  2370. /* Use the code below as a template for the implementation class for this interface. */
  2371.  
  2372. /* Header file */
  2373. class nsDOMSVGPathSegCurvetoQuadraticSmoothRel : public nsIDOMSVGPathSegCurvetoQuadraticSmoothRel
  2374. {
  2375. public:
  2376.   NS_DECL_ISUPPORTS
  2377.   NS_DECL_NSIDOMSVGPATHSEGCURVETOQUADRATICSMOOTHREL
  2378.  
  2379.   nsDOMSVGPathSegCurvetoQuadraticSmoothRel();
  2380.  
  2381. private:
  2382.   ~nsDOMSVGPathSegCurvetoQuadraticSmoothRel();
  2383.  
  2384. protected:
  2385.   /* additional members */
  2386. };
  2387.  
  2388. /* Implementation file */
  2389. NS_IMPL_ISUPPORTS1(nsDOMSVGPathSegCurvetoQuadraticSmoothRel, nsIDOMSVGPathSegCurvetoQuadraticSmoothRel)
  2390.  
  2391. nsDOMSVGPathSegCurvetoQuadraticSmoothRel::nsDOMSVGPathSegCurvetoQuadraticSmoothRel()
  2392. {
  2393.   /* member initializers and constructor code */
  2394. }
  2395.  
  2396. nsDOMSVGPathSegCurvetoQuadraticSmoothRel::~nsDOMSVGPathSegCurvetoQuadraticSmoothRel()
  2397. {
  2398.   /* destructor code */
  2399. }
  2400.  
  2401. /* attribute float x; */
  2402. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::GetX(float *aX)
  2403. {
  2404.     return NS_ERROR_NOT_IMPLEMENTED;
  2405. }
  2406. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::SetX(float aX)
  2407. {
  2408.     return NS_ERROR_NOT_IMPLEMENTED;
  2409. }
  2410.  
  2411. /* attribute float y; */
  2412. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::GetY(float *aY)
  2413. {
  2414.     return NS_ERROR_NOT_IMPLEMENTED;
  2415. }
  2416. NS_IMETHODIMP nsDOMSVGPathSegCurvetoQuadraticSmoothRel::SetY(float aY)
  2417. {
  2418.     return NS_ERROR_NOT_IMPLEMENTED;
  2419. }
  2420.  
  2421. /* End of implementation class template. */
  2422. #endif
  2423.  
  2424.  
  2425. #endif /* __gen_nsIDOMSVGPathSeg_h__ */
  2426.